unist-util-remove

What is unist-util-remove?

The unist-util-remove package is a utility for removing nodes from a Unist syntax tree. It allows you to filter out nodes based on specific criteria, making it useful for manipulating abstract syntax trees (ASTs) in various text processing tasks.

What are unist-util-remove's main functionalities?

Remove nodes by type

This feature allows you to remove all nodes of a specific type from the tree. In this example, all 'paragraph' nodes are removed from the tree.

const remove = require('unist-util-remove');
const tree = { type: 'root', children: [ { type: 'paragraph', children: [ { type: 'text', value: 'Hello' } ] }, { type: 'paragraph', children: [ { type: 'text', value: 'World' } ] } ] };
remove(tree, 'paragraph');
console.log(tree);

Remove nodes by test function

This feature allows you to remove nodes based on a test function. In this example, only the 'paragraph' node containing the text 'World' is removed.

const remove = require('unist-util-remove');
const tree = { type: 'root', children: [ { type: 'paragraph', children: [ { type: 'text', value: 'Hello' } ] }, { type: 'paragraph', children: [ { type: 'text', value: 'World' } ] } ] };
remove(tree, node => node.type === 'paragraph' && node.children[0].value === 'World');
console.log(tree);

Remove nodes by index

This feature allows you to remove nodes by their index in the parent node's children array. In this example, the second 'paragraph' node (index 1) is removed.

const remove = require('unist-util-remove');
const tree = { type: 'root', children: [ { type: 'paragraph', children: [ { type: 'text', value: 'Hello' } ] }, { type: 'paragraph', children: [ { type: 'text', value: 'World' } ] } ] };
remove(tree, { type: 'paragraph' }, 1);
console.log(tree);

Other packages similar to unist-util-remove

unist-util-filter

The unist-util-filter package allows you to filter nodes in a Unist tree based on a test function. It is similar to unist-util-remove but instead of removing nodes, it creates a new tree with only the nodes that pass the test.

unist-util-visit

The unist-util-visit package is used to recursively walk through a Unist tree and perform actions on nodes that match a specific type or test function. While it doesn't remove nodes, it can be used in conjunction with other utilities to manipulate the tree.

unist-util-map

The unist-util-map package allows you to transform nodes in a Unist tree by applying a function to each node. It is useful for modifying the tree structure or node values, but it does not directly remove nodes.

README

unist-util-remove

unist utility to modify the given tree by removing all nodes that pass the given test.

Install

npm:

npm install unist-util-remove

Usage

var u = require('unist-builder')
var remove = require('unist-util-remove')

var tree = u('root', [
  u('leaf', '1'),
  u('node', [
    u('leaf', '2'),
    u('node', [u('leaf', '3'), u('other', '4')]),
    u('node', [u('leaf', '5')])
  ]),
  u('leaf', '6')
])

// Remove all nodes of type `leaf`.
remove(tree, 'leaf')

console.dir(tree, {depth: null})

Yields: (note the parent of 5 is also removed, due to options.cascade)

{
  type: 'root',
  children: [
    {
      type: 'node',
      children: [
        { type: 'node', children: [ { type: 'other', value: '4' } ] }
      ]
    }
  ]
}

API

remove(tree[, options][, test])

Mutate the given tree by removing all nodes that pass test. The tree is walked in preorder (NLR), visiting the node itself, then its head, etc.

Parameters

• tree (Node?) — Tree to filter
• options.cascade (boolean, default: true) — Whether to drop parent nodes if they had children, but all their children were filtered out
• test (Test, optional) — is-compatible test (such as a type)

Returns

Node? — The given tree with nodes for which test passed removed. null is returned if tree itself didn’t pass the test, or is cascaded away.

Related

• unist-util-filter — Create a new tree with all nodes that pass the given function
• unist-util-flatmap — Create a new tree by expanding a node into many
• unist-util-map — Create a new tree by mapping nodes
• unist-util-select — Select nodes with CSS-like selectors
• unist-util-visit — Recursively walk over nodes
• unist-builder — Creating trees

Contribute

See contributing.md in syntax-tree/.github for ways to get started. See support.md for ways to get help.

This project has a Code of Conduct. By interacting with this repository, organisation, or community you agree to abide by its terms.

License

MIT © Eugene Sharygin